New experimental /helix route (BodyHelix.tsx), parallel to /body and sharing
nothing with it, so the working /body can never break.

Shades from the per-vertex helix NORMAL using the canonical lance-graph
helix::Signed360 codec (6 bytes: rim endpoint pair + signed polar lift +
golden azimuth), which is place-coupled to the HHTL address — encode(place, n)
takes the HHTL place as its first argument. Decode: y from the polar partition,
phi from the u16 azimuth, r = sqrt(1 - y^2), world (r*sin phi, y, r*cos phi).
Decoded once at load into an octahedral-i8 x2 vertex attribute so the GPU reads
the normal natively (normalized fetch, ~4-ALU octa decode) — no texture, no
per-frame work.

Canonical-only: reads the stamped helix bake named by body.manifest.json
(helix_latest); deliberately does NOT fall back to the shared body.soa.gz,
whose normals use the older place-blind helix_orient codec and would render
garbage if read as Signed360.

Also adds crates/osint-bake/tools/BAKE_ARTIFACTS.md: date/format-stamped bake
naming + a manifest so a new bake never clobbers the working artifact.

Follow-up (separate commit): the matching soabake change to GENERATE these
normals via helix::ResidueEncoder::encode_signed(place, n, sign) instead of
helix_orient — i.e. the rebake. Decoder and encoder get validated together at
bake time.

…ls for /helix

New standalone crate scratch-fma/helixbake (its own [workspace]), side-by-side
with scratch-fma/soabake (the /body bake), which is left BYTE-IDENTICAL — the old
pipeline never resolves helix.

Generates the per-vertex NORMAL with the canonical lance-graph helix algorithm,
not a re-derivation:
- nearest spherical-Fibonacci index n of the world normal (same phi-spiral
  helix::HemispherePoint::lift walks),
- helix::ResidueEncoder::encode_signed(place, n, sign) -> 6-byte Signed360,
  place = the concept's HHTL path (HEEL/HIP/TWIG) so the rim anchors on the
  place via CurveRuler::from_place ('normal residue on top of HHTL'),
- the Fisher-Z RollingFloor is built once (pre-materialized), shared across all
  vertices; per-vertex encode is table lookups + quantize.

Emits BSO2 ver 6 (F16 pos + Signed360 helix-normal column), a stamped artifact
per BAKE_ARTIFACTS.md; the render direction lives in (polar, azimuth) and is
place-independent, which BodyHelix.tsx decodes -> octahedral i8 (cheap on CPU
SIMD and GPU-less WebGL, no per-vertex trig materialization).

Includes a #[test] round-tripping encode->decode (the same decode the viewer
runs) on synthetic normals, < 1.5deg, no FMA data needed. Cargo manifest patches
helix's git ndarray to the local fork; this sandbox's proxy blocks that fetch, so
the crate is validated on a network-enabled bake host, not here. soabake and
/body are unaffected.

…l materialization

The Signed360 (polar, azimuth) are NORMALIZED angular coordinates; reconstructing
the Cartesian normal per vertex (√/sin/cos — and the rim's Fisher-Z/atanh) is
unnecessary materialization. Replace it with a pre-materialized direction LUT:

- buildDirLut() runs the trig ONCE (256 polar × 1024 azimuth ≈ 262k cells), not
  per the 4.2M vertices.
- decode() now only copies each vertex's (polar, az_lo, az_hi) bytes into the
  aPolAz attribute — zero trig in the per-vertex path.
- the vertex shader is a single normalized-index LUT fetch keyed by (polar,
  azimuth); equivalently a CPU-SIMD gather, so it stays cheap without a GPU.

The rim (Fisher-Z / atanh endpoints) is the metric carrier and is never
materialized for rendering — only (polar, azimuth) drive the normal.

…ders

Makes /helix actually run, end-to-end on real data, without the FMA source
pipeline or a helix build:

- transcode_helix_signed360.py: fetches nothing itself, takes the released ver-5
  body wire, decodes the old ndarray helix_orient normals back to Cartesian, and
  re-encodes the Signed360 render coords (polar partition + golden azimuth; the
  rim/metric is unused by rendering, left zero). Emits an HXN1 sidecar —
  'HXN1' | nV u32 | (polar,az_lo,az_hi)[nV] — vertex-aligned to body.soa.gz.
  VERIFIED by decoding back exactly as the viewer does: mean 0.205 deg, p99
  1.37 deg, max 5.09 deg over all 4,283,525 verts.

- BodyHelix now loads TWO same-origin files: the shared body.soa.gz (geometry —
  already served for /body, no duplication) and the small HXN1 sidecar (normals,
  named by body.manifest.json helix_latest). The wire's own old-codec normals are
  never read. Per-vertex is still a normalized (polar,azimuth) LUT lookup — no trig.

- cockpit/public/: the 12 MB sidecar gz + body.manifest.json (helix_latest),
  served same-origin via dist; geometry stays the release-pulled body.soa.gz.

This is a render-faithful transcode (double-quantized through helix_orient, hence
the few-degree tail); the metric-coupled artifact from helixbake on the FMA
columns remains the eventual canonical replacement, drop-in via the same sidecar.

Per review: (1) the normals belong as a COLUMN of the same SoA as the positions,
not interlaced across a second file; (2) the artifact belongs in a release, not
committed to the repo.

- transcode_helix_signed360.py: back to emitting ONE BSO2 ver-6 wire — F16 pos +
  a canonical Signed360 NORMAL column in the same struct-of-arrays (drops the HXN1
  sidecar). Verified decode-back: mean 0.205 deg, p99 1.37 deg over 4,283,525 verts.
- The 60 MB ver-6 wire is uploaded to the fma-body-soa-v3-v1 release (via
  GH_TOKEN + pygithub), NOT committed. Removed the 12 MB sidecar from public/.
- BodyHelix reverts to a single-wire reader (the wire's Signed360 helix column →
  pre-materialized direction LUT, one gather per vertex; no per-vertex trig).
- Dockerfile pulls body.20260628.v6helix.soa.gz into dist/ same-origin (same CORS
  reason as body.soa.gz); body.manifest.json (committed, small) names it via
  helix_latest.

…ering

- Dead buttons: the layer-toggle effect reassigned enabledRef.current to a NEW
  array, but mount() captured the original array, so uEnabled never changed.
  Mutate the array IN PLACE instead → toggles reach the shader.
- Slowness, two safe levers (no codec change):
  - on-demand render: the 6.8 M-tri body is redrawn ONLY on drag/zoom/toggle/
    resize, not every frame — idle is free, far less heat.
  - adaptive pixel ratio: drop to 1x when a frame exceeds the ~30 fps budget;
    on a retina phone this quarters/ninths the fragment load while rotating.

Does not touch the wire or the normalized Signed360 decode. The deeper cost
(per-vertex LUT gather over 6.8 M tris) is a mobile-vertex-fetch / LOD question,
flagged separately.

Bake the /helix Signed360 normals with the REAL lance-graph::helix
crate (ResidueEncoder::encode_signed) against the local ndarray fork,
instead of the hand-rolled transcoder that ZEROED the Fisher-Z rim.
The rim (rim.end = arctanh(r) quantised, r = sinθ) is now populated —
the "palette256 = the angle" carrier — and the wire carries an HXFL
trailer with the exact RollingFloor (lo,hi) so the decoder dequantises
with the same floor the encoder used. Single SoA wire (BSO2 ver 6),
new stamped artifact body.20260629.v6helix.soa.gz; the prior bake is
kept in the release, not deleted.

BodyHelix now DECODES the rim: r=sinθ is reconstructed from rim.end via
a 256-entry r-LUT (the only place atanh/tanh runs — at load, never per
vertex), the polar partition gives the hemisphere sign and covers the
r→1 saturation cliff. Each vertex becomes a normalized int8 NORMAL.

Render switched to GOURAUD: lighting computed per-vertex from the cheap
int8 normal, colour interpolated; the fragment shader drops to a layer
discard + colour write. At 6.8M sub-pixel tris this is visually identical
to per-fragment lighting but removes the per-fragment normalize/dot that
made it 12 s/frame. No LUT texture fetch per vertex either.

Verified end-to-end on all 4,283,525 source normals: browser decode vs
source mean 0.263°, p99 0.918°, max 1.924°, 0% over 2°.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RhpwkHGgia2TuDFvdnuQdE